package donkeykong;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;

import javax.imageio.ImageIO;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.UnsupportedAudioFileException;
import javax.swing.JPanel;
import javax.swing.Timer;

/**
 * 
 * @author Antonio Cebollada, Miguel Castillo, José Ignacio Castro
 *
 */

public class SegundoNivel extends JPanel{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	/** Imagen del nivel/pantalla  **/
	private Image imagenFondo;
	/** Referencia al DK **/
	private DonkeyKong dk;
	/** Referencia a Mario **/
	private Mario mario;
	/** Timer que cada cierto tiempo, enviará un evento Action**/
	private Timer t;
	/** Clip que permite iniciar o parar la musica, entre otras opciones **/
	private static Clip clickClip;
	/** Stream de la musica que suena**/	
	private AudioInputStream musicaFondo;
	/** Thread que se utiliza para lanzar un codigo en segundo plano **/
	private Thread thread=null;
	
	
	private int NivelDificultad;
	
	private ArrayList<Muelle> muelles;
	private ArrayList<Espectro> espectros;
	
	private ArrayList<Ascensor> asc1;
	private ArrayList<Ascensor> asc2;
	
	private Puntuacion_total score;
	private Objeto objeto1, objeto2;
	private Pauline pauline;
	
	private ClaseListener cl;
	private boolean acabarNivel;
	
	/** Constructor
	 * 
	 * @param vidas			: vidas de Mario
	 * @param pt 
	 * @param altadificultad: dificultad del juego alta (true) o baja (false)
 	 * @p
 	 */

	public SegundoNivel(int vidas, int niveldificultad, Puntuacion_total pt) {
		try {
			
			muelles = new ArrayList<Muelle>();
			espectros = new ArrayList<Espectro>();
			asc1 = new ArrayList<Ascensor>();
			asc2 = new ArrayList<Ascensor>();
			
			
			pauline = new Pauline(310,50);
			Thread TPauline = new Thread(pauline);
			TPauline.setName("PAULINE");
			TPauline.start();
			
			NivelDificultad = niveldificultad;
			imagenFondo = ImageIO.read(new File("./pantallas/nivel_2b.png"));
			
			/** Colocar a Mario en la posicion correspondiente **/
			mario = new Mario(60,525,2,vidas);
			//mario = new Mario(360,117,2,vidas);
			
			Puntuacion_total pt2 = new Puntuacion_total(pt.getTECLA_ABAJO(),pt.getTECLA_ARRIBA(),pt.getTECLA_DERECHA(),pt.getTECLA_IZQUIERDA(),pt.getTECLA_SALTO(),pt.getTECLA_START(),niveldificultad);
			score = pt2;
			score.setMario(mario);
			score.ReiniciarTiempo();
			score.añadirPuntuacion(pt.obtenerPuntuacion());
			Thread TpuntuacionTotal = new Thread(score);
			TpuntuacionTotal.setName("PUNTUACIONTOTAL");
			TpuntuacionTotal.start();
			
			
			
			/** Colocar al DK en la posicion correspondiente **/
			dk = new DonkeyKong(125,112,2,(BufferedImage)imagenFondo, muelles, mario,espectros, asc1, asc2,score,NivelDificultad);  //Posicion en el nivel '2' del Donkey Kong
			
			Thread Tdk = new Thread(dk);
			
			objeto1 = new Objeto(40,291,mario, "paraguas", score);
			Thread paraguas = new Thread(objeto1);
			paraguas.start();
			
			objeto2 = new Objeto(670,206,mario, "bolso", score);
			Thread bolso = new Thread(objeto2);
			bolso.start();
			
			cl = new ClaseListener();
			addKeyListener(cl);	
			requestFocusInWindow();
			escucharMusicaFondo("Nivel1_theme", 0);
			t = new Timer(100,cl);
			t.start();
			Tdk.start();
		} catch (IOException e) {
			e.printStackTrace();
		}	
	}
	
	/** Funcion de inicializar que añade los JPanels de los objetos que aparecen en la pantalla al JFrame para que puedan pintarse correctamente **/
	public void inicializar() {
		//getParent().add(dk);
		getParent().add(mario);
		
	}
	
	
	/** Funcion paintComponent que es propia de los JPanels, que sirve para dibujar en el mismo la imagen que se quiera, entre otras opciones 
	 *  A través de este Paint, se pintaran los de los demas objetos que aparezcan en el nivel, desde Mario, DK, la princesa, los enemigos, objetos...
	 * **/
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		Graphics2D g2d = (Graphics2D) g;
		g2d.drawImage(imagenFondo,0,0,null);
		
		
		score.paintComponent(g);
		
		/** Pintar al DK **/
		if (mario.isMuriendo()){
			score.Acabar();
			dk.DKparado();
		}
		
		if (!dk.raptoCompleto())
			dk.paintComponent(g);
		
		/** Pintar a Mario **/
		mario.paintComponent(g);
		
		/** Pintar a Pauline **/
		pauline.paintComponent(g);
		
		/** Pintar el muelle **/
		if (!muelles.isEmpty()){
			for (int i=0;i<muelles.size();i++){
				if (mario.isMuriendo()){
					muelles.get(i).MarioMuerto();
				}
						
				if (muelles.get(i).isAcabado()){
					muelles.remove(i);
				}
				
				if (i != muelles.size()){
					muelles.get(i).paintComponent(g);}

			}
		}
		
		if (objeto1.isActivo()){
			objeto1.paintComponent(g);
		}
		
		if (objeto2.isActivo()){
			objeto2.paintComponent(g);
		}
		
		/** Pintar los enemigos que haya activos **/
		if (!espectros.isEmpty()){
			for (int i=0;i<espectros.size();i++){
				if (espectros.get(i).isAcabado()){
					espectros.remove(i);
				}
				if (i != espectros.size()){
					espectros.get(i).paintComponent(g);
				}
			}
		}
		
		
		if (!asc1.isEmpty()){
			for (int i=0;i<asc1.size();i++){
				if (mario.isMuriendo()){
					asc1.get(i).MarioMuerto();
				}
						
				if (asc1.get(i).isAcabado()){
					asc1.remove(i);
				}
				
				if (i != asc1.size()){
					asc1.get(i).paintComponent(g);}

			}
		}
		
		if (!asc2.isEmpty()){
			for (int i=0;i<asc2.size();i++){
				if (mario.isMuriendo()){
					asc2.get(i).MarioMuerto();
				}
						
				if (asc2.get(i).isAcabado()){
					asc2.remove(i);
				}
				
				if (i != asc2.size()){
					asc2.get(i).paintComponent(g);}

			}
		}

		
		

		
		g2d.dispose();

	}
	
	
	/** Funcion para escuchar la musica de fondo del nivel **/
	public void escucharMusicaFondo(String sonido, int duracion){
		try {
			clickClip = AudioSystem.getClip();
			musicaFondo = AudioSystem.getAudioInputStream(new File("./sounds/"+sonido+".wav"));
			clickClip.open(musicaFondo);
			clickClip.loop(duracion);
			clickClip.start();
		} catch (LineUnavailableException e) {
			e.printStackTrace();
		} catch (UnsupportedAudioFileException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
	
	
	/** Funcion que invalida los listeners porque se pasa de nivel, y realiza todas las animaciones y elminaciones de objetos **/
	public void PasarNivel() {
		dk.DKPasarPantalla();
		dk.Pauline(pauline);
		setAcabarNivel(true);
		
		mario.pasarPantalla();
		removeKeyListener(cl);

		
		for (int i=0;i<espectros.size();i++){
				espectros.get(i).Acabar();
		}
		for (int i=0;i<muelles.size();i++){
			muelles.get(i).MarioMuerto();
		}
		
		
		clickClip.stop();
		clickClip.close();
		escucharMusicaFondo("Stage_Clear", 0);
		pauline.Rescatada(dk);
		

	}
	
	
	private void setAcabarNivel(boolean b) {
		acabarNivel = b;
	}


	public boolean getAcabandoNivel() {
		return acabarNivel;
	}
	
	/** Clase que implementa el listener de teclas y un listener de eventos de Timer **/
	private class ClaseListener extends KeyAdapter implements ActionListener{

		/** Numero de colores de escalera que Mario debe reconocer para poder subirla **/
		private static final int COLORES_ESCALERA = 5;
		/** Variacion de la posicion Y de Mario mientras esta subiendo/bajando una escalera **/
		private static final int INCREMENTO_ESCALERAS = 4;
		/** Variables que indican si Mario se esta moviendo hacia la izquierda o hacia la derecha **/
		private boolean moviendoIzquierda, moviendoDerecha;
		/** Variable que indica si Mario esta muerto **/
		private boolean finalmentemuerto=false;
		/** Teclas de movimiento y accion (salto **/
		private int 
				TECLA_ARRIBA=KeyEvent.VK_W,
				TECLA_ABAJO=KeyEvent.VK_S,
				TECLA_DERECHA=KeyEvent.VK_D,
				TECLA_IZQUIERDA=KeyEvent.VK_A,
				TECLA_SALTAR=KeyEvent.VK_SPACE;
		
		private boolean mario_en_ascensor;
		
		public ClaseListener(){
			TECLA_ARRIBA=score.getTECLA_ARRIBA();
			TECLA_ABAJO=score.getTECLA_ABAJO();
			TECLA_DERECHA=score.getTECLA_DERECHA();
			TECLA_IZQUIERDA=score.getTECLA_IZQUIERDA();
			TECLA_SALTAR=score.getTECLA_SALTO();
		}
		
		
		/**Si se presiona una tecla**/
		public void keyPressed(KeyEvent arg0) {
			/** Si Mario no esta muriendo **/
			if(!mario.isMuriendo()){
				 if (arg0.getKeyCode() == TECLA_SALTAR){
					 /** Si no esta ya saltando ni subiendo/bajando una escalera, se puede saltar **/
					if (!mario.isSaltando()&!mario.isSubiendoEscalera()){	
							/** Parar el sonido que lleve Mario **/
							mario.pararSonido();
							/** Escuchar sonido de salto **/
							mario.escucharSonido("jump",0);
							//t.start();
							/** Iniciar la clase de salto **/
							Saltar saltoMario = new Saltar(mario,imagenFondo, asc1, asc2,2);
							Thread T = new Thread(saltoMario);
							T.start();
							repaint();
								
					}
					
				}
				if (arg0.getKeyCode() == TECLA_IZQUIERDA){
					/** SI no esta ya saltando, ni moviendose, ni subiendo una escalera **/
					if (!mario.isSaltando()&!mario.isMoviendose()&!mario.isSubiendoEscalera()){
						/** Comprobar que no hay colision por la izquierda **/
						if (!mario.detectarColision_izq(mario.getEsquina())){
							/** Modificar variables de sentido de andar **/
							moviendoIzquierda=true;
							moviendoDerecha=false;
							mario.MostrarParadoIzq();
							
							/** Comprobar el suelo, esta funcion es la que indica en todo momento lo que debe hacer Mario con la pantalla **/
							mario_en_ascensor = false;
							/** Con esto comprobamos, si para alguno de los ascensores está mario subido. Es importante 
							 * ya que si Mario está subido en un ascensor, no hay que llamar a la función comprobar suelo **/
							for (int i=0;i<asc1.size();i++){
								if (asc1.get(i).isEn_ascensor_1()){
									mario_en_ascensor=true;
								}
							}
							for (int i=0;i<asc2.size();i++){
								if (asc2.get(i).isEn_ascensor_2()){
									mario_en_ascensor=true;
								}
							}
							/** Si Mario no esta en ascensor, hay que comprobar el suelo **/
							if (! mario_en_ascensor){
							 comprobarSuelo(mario.getCentroMario(),(BufferedImage) imagenFondo);
							}
							repaint();
							/** Escuchar sonido de andar **/
							mario.escucharSonido("walking",Clip.LOOP_CONTINUOUSLY);
							//t.start();
							
							mario.moviendose();
							repaint();
							
						/** Si se detecta colision, parar el movimiento **/	
						}else{
							mario.pararse();	
							//t.start();
						}
					}else{
						/** Si Mario no esta saltando ni subiendo una escalera, es decir, que ya se esta moviendo, solamente ir comprobando el suelo **/
						if(!mario.isSaltando()&!mario.isSubiendoEscalera()){
							mario_en_ascensor = false;
							for (int i=0;i<asc1.size();i++){
								if (asc1.get(i).isEn_ascensor_1()){
									mario_en_ascensor=true;
								}
							}
							for (int i=0;i<asc2.size();i++){
								if (asc2.get(i).isEn_ascensor_2()){
									mario_en_ascensor=true;
								}
							}
							if (! mario_en_ascensor){
							 comprobarSuelo(mario.getCentroMario(),(BufferedImage) imagenFondo);
							}
						}
					}
	
				}
				if (arg0.getKeyCode() == TECLA_DERECHA){
					/** SI no esta ya saltando, ni moviendose, ni subiendo una escalera **/
					if (!mario.isSaltando()&!mario.isMoviendose()&!mario.isSubiendoEscalera()){
						/** Comprobar que no hay colision por la derecha **/
						if (!mario.detectarColision_dch(mario.getEsquina())){
							/** Modificar variables de sentido de andar **/
							moviendoDerecha=true;
							moviendoIzquierda=false;
							mario.MostrarParadoDch();
							
							/** Comprobar el suelo, esta funcion es la que indica en todo momento lo que debe hacer Mario con la pantalla **/
							mario_en_ascensor = false;
							for (int i=0;i<asc1.size();i++){
								if (asc1.get(i).isEn_ascensor_1()){
									mario_en_ascensor=true;
								}
							}
							for (int i=0;i<asc2.size();i++){
								if (asc2.get(i).isEn_ascensor_2()){
									mario_en_ascensor=true;
								}
							}
							if (! mario_en_ascensor){
							 comprobarSuelo(mario.getCentroMario(),(BufferedImage) imagenFondo);
							}
							repaint();
							/** Escuchar sonido de andar **/
							mario.escucharSonido("walking",Clip.LOOP_CONTINUOUSLY);
							//t.start();

							mario.moviendose();
							repaint();
							
						/** Si se detecta colision, parar el movimiento **/	
						}else{
							mario.pararse();
							//t.start();
						}					
					}else{
						/** Si Mario no esta saltando ni subiendo una escalera, es decir, que ya se esta moviendo, solamente ir comprobando el suelo **/
						if(!mario.isSaltando()&!mario.isSubiendoEscalera()){
							mario_en_ascensor = false;
						for (int i=0;i<asc1.size();i++){
							if (asc1.get(i).isEn_ascensor_1()){
								mario_en_ascensor=true;
							}
						}
						for (int i=0;i<asc2.size();i++){
							if (asc2.get(i).isEn_ascensor_2()){
								mario_en_ascensor=true;
							}
						}
						if (! mario_en_ascensor){
						 comprobarSuelo(mario.getCentroMario(),(BufferedImage) imagenFondo);
						}
						}
					}
	
				}
				
				if (arg0.getKeyCode() == TECLA_ARRIBA){
					/** Si Mario no esta saltando ni moviendose, puede subir/bajar una escalera **/
					if (!mario.isSaltando()&!mario.isMoviendose()){
						BufferedImage image1 = (BufferedImage) imagenFondo;
						int coloresAzules=0;
						/** Comprobar el numero de pixeles del color de la escalera a lo largo de la imagen de Mario **/
						for (int i=mario.getPosicion_x();i<=mario.getPosicion_x()+mario.getImage().getWidth(null);i++){
							int c1 = image1.getRGB(i,mario.getPosicion_y()-1);
							Color color = new Color(c1);
							if (EsEscalera(color)){
								coloresAzules ++;
							}
						}
						/** Si el numero de colores de escalera se corresponde con el minimo para interactuar, se interactua con ella **/
						if (coloresAzules >= COLORES_ESCALERA){
							/** Mostrar animacion con las escaleras **/
							mario.animacionEscaleras();
							mario.subiendoEscalera();
							
							/** Comprobar pixel a pixel si estamos llegando a un color de suelo, que indicaria que terminamos de subir/bajar **/
							for (int j=1;j<=INCREMENTO_ESCALERAS;j++){
								mario.setPosicion_y(mario.getPosicion_y()-1);
								int c1 = image1.getRGB(mario.getCentroMario(),mario.getPosicion_y());
								Color color = new Color(c1);
								if (EsSuelo(color)){
									mario.setPosicion_y(mario.getPosicion_y()-1);
									mario.dejaEscalera();
									j=INCREMENTO_ESCALERAS;
								}
							
							}						
							
						/** Si no detectamos escalera, y estamos en una posicion de aire, es que nos hemos quedado
						*	encasillados en una escalera, al final o al principio, salvamos ese error
						**/							
						}else if (coloresAzules==0){   
							int c1 = image1.getRGB(mario.getCentroMario(),mario.getPosicion_y());
							Color color = new Color(c1);
							if (EsAire(color)){
								mario.setPosicion_y(mario.getPosicion_y()+1);
							}
						}
						//t.start();
					}
	
				}
				if (arg0.getKeyCode() == TECLA_ABAJO){
					/** Si Mario no esta saltando ni moviendose, puede subir/bajar una escalera **/
					if (!mario.isSaltando()&!mario.isMoviendose()){
						BufferedImage image1 = (BufferedImage) imagenFondo;
						int coloresAzules=0;
						/** Comprobar el numero de pixeles del color de la escalera a lo largo de la imagen de Mario **/
						for (int i=mario.getPosicion_x();i<=mario.getPosicion_x()+mario.getImage().getWidth(null);i++){
							int c1 = image1.getRGB(i,mario.getPosicion_y()+1);
							Color color = new Color(c1);
							if (EsEscalera(color)){
								coloresAzules ++;
							}
						}
						/** Si el numero de colores de escalera se corresponde con el minimo para interactuar, se interactua con ella **/
						if (coloresAzules >= COLORES_ESCALERA){
							/** Mostrar animacion con las escaleras **/
							mario.animacionEscaleras();
							mario.subiendoEscalera();
							
							/** Comprobar pixel a pixel si estamos llegando a un color de suelo, que indicaria que terminamos de subir/bajar **/
							for (int j=1;j<=INCREMENTO_ESCALERAS;j++){
								mario.setPosicion_y(mario.getPosicion_y()+1);
								int c1 = image1.getRGB(mario.getCentroMario(),mario.getPosicion_y());
								Color color = new Color(c1);
								if (EsSuelo(color)){
									mario.dejaEscalera();
									j=INCREMENTO_ESCALERAS;
								}
							
							}
							
						/** Si no detectamos escalera, y estamos en una posicion de aire, es que nos hemos quedado
						*	encasillados en una escalera, al final o al principio, salvamos ese error
						**/		
						}else if (coloresAzules==0){
							int c1 = image1.getRGB(mario.getCentroMario(),mario.getPosicion_y());
							Color color = new Color(c1);
							if (EsAire(color)){
								mario.setPosicion_y(mario.getPosicion_y()+1);
							}
						}
						//t.start();

					}
				}
				
			/** Si Mario esta muerto, dejar de reproducir la musica **/
			}else{
				clickClip.stop();
				clickClip.close();

			}
			
		}
		
		/** Funcion que se llama cuando se suelta una tecla **/
		public void keyReleased(KeyEvent arg0) {
			/** Si Mario no esta muriendo **/
			if (!mario.isMuriendo()){
				if (arg0.getKeyCode() == TECLA_DERECHA){
					/** Si Mario no esta ni saltando ni moviendose ni en una escalera **/
					if(!mario.isSaltando()&!mario.isMoviendose()&!mario.isSubiendoEscalera()){
						mario.pararSonido();
						moviendoDerecha=false;
						mario.pararse();
						mario.MostrarParadoDch();
						/** Parar el Timer para que no siga pintando automaticamente **/
						t.restart();
						repaint();
					}else{
						if (!mario.isSaltando())
							mario.pararSonido();
						moviendoDerecha=false;
						mario.pararse();					
					}
				}
				if(arg0.getKeyCode() == TECLA_IZQUIERDA){
					/** Si Mario no esta ni saltando ni moviendose ni en una escalera **/
					if (!mario.isSaltando()&!mario.isMoviendose()&!mario.isSubiendoEscalera()){
						mario.pararSonido();
						moviendoIzquierda=false;
						mario.pararse();
						mario.MostrarParadoIzq();
						/** Parar el Timer para que no siga pintando automaticamente **/
						t.restart();
						repaint();
					}else{
						if (!mario.isSaltando())
							mario.pararSonido();
						moviendoDerecha=false;
						mario.pararse();					
					}
				}
			/** Si Mario esta muerto, dejar de reproducir la musica **/	
			}else{
				clickClip.stop();
				clickClip.close();

			}
		}

		/** Funcion que se encarga de repintar cada cierto tiempo y teniendo en cuenta los estados en los que se puede encontrar Mario **/
		@Override
		public void actionPerformed(ActionEvent arg0) {
			
			/** Comprobar si ha llegado a la meta **/
			if (mario.getPosicion_y()<107){
				/** Si ha llegado a la meta y esta ejecutando la escena, no volver a ejecutarla, y cuando el rapto se complete, cambiar de nivel **/
				if (!getAcabandoNivel()){
					score.Acabar();
					score.añadirPuntuacion(score.getTiempo());
					score.pararSonido();
					PasarNivel();
				}else{
					if (dk.raptoCompleto()){
						CambiarNivel();
					}
				}
			}
			
			
			/** Si no se tiene que resetear el nivel **/
			if (!mario.isResetearNivel()){
				/** Si Mario no esta muerto **/
				if(!mario.isMuriendo()){
					/** Si mario se esta moviendo pero no esta en una escalera **/
					if (mario.isMoviendose() & !mario.isSubiendoEscalera() & !mario.isSaltando()){
							/** Comprobar si se esta moviendo en izquierda o en derecha para moverlo en esa direccion y repintar **/
							if (moviendoIzquierda){
									mario.moverIzquierda();
									repaint();
							}else if (moviendoDerecha){
									mario.moverDerecha();
									repaint();
							}
							/** Si Mario no esta saltando, comprobar en todo momento el suelo **/
							if (!mario.isSaltando())
								mario_en_ascensor = false;
							for (int i=0;i<asc1.size();i++){
								if (asc1.get(i).isEn_ascensor_1()){
									mario_en_ascensor=true;
								}
							}
							for (int i=0;i<asc2.size();i++){
								if (asc2.get(i).isEn_ascensor_2()){
									mario_en_ascensor=true;
								}
							}
							if (! mario_en_ascensor){
							 comprobarSuelo(mario.getCentroMario(),(BufferedImage) imagenFondo);
							}
		
					}
				/** Mario esta muerto, se debe dejar de reproducir la musica y ejecutar la clase Muerto, para que ejecute la
				 * secuencia de muerte de Mario.	
				 */
				}else{  
					if (!finalmentemuerto){
						mario.pararSonido();
						clickClip.stop();
						clickClip.close();

						finalmentemuerto=true;
						Muerto muerto = new Muerto(mario);
						thread = new Thread(muerto);
						thread.start();
					}
				}
				repaint();

			/** Se tiene que resetear el nivel**/
			}else{
				resetearNivel();
			}
			
		}

		
	}
	
	
	/** Funcion de resetear nivel, elimina los JPanel innecesarios, y vuelve a ejecutar la clase Intermedio **/
	public void resetearNivel() {
		t.stop();
		mario.pararSonido();
		dk.morir();
		score.Acabar();
		score.pararSonido();
		
		/** Borrar los Threads de los enemigos que haya activos **/
		if (!espectros.isEmpty()){
			for (int i=0;i<espectros.size();i++){
				espectros.get(i).Acabar();
			}
		}
		
		pauline.Morir();
		muelles = new ArrayList<Muelle>();
		getParent().remove(dk);
		getParent().remove(mario);
		Intermedio it = new Intermedio(2, mario.getVidas(), NivelDificultad, score);
		getParent().add(it);
		it.setVisible(true);
		setVisible(false);
		getParent().remove(this);
		it.requestFocusInWindow();		
	}
	
	
	/** Funcion de cambiar al tercer nivel, elimina los JPanel innecesarios, y vuelve a ejecutar la clase Intermedio **/
	public void CambiarNivel() {
		t.stop();
		getParent().remove(dk);
		getParent().remove(mario);
		Intermedio it = new Intermedio(3, mario.getVidas(), NivelDificultad, score);
		getParent().add(it);
		it.setVisible(true);
		setVisible(false);
		getParent().remove(this);
		it.requestFocusInWindow();		
	}
	/** Funcion de comprobar suelo, sirve para poder moverse por la pantalla, poder caer, subir/bajar escaleras,etc **/
	public void comprobarSuelo(int centroMario,BufferedImage image1){
		
		int c1 = image1.getRGB(centroMario,mario.getPosicion_y());
		Color color = new Color(c1);
		/** Comprobar el suelo si es negro, (color del aire) , es bajar posicion 'y' hasta encontrar color de suelo **/
		if ((EsAire(color))){
			c1 = image1.getRGB(centroMario,mario.getPosicion_y());
			color = new Color(c1);
			int caida=0;
			/** Mientras el color no sea el del suelo, bajar **/
			while (!(EsSuelo(color))){
				if (mario.EsBaseAscensor(color)){
					mario.Muriendo();
					mario.pararSonido();
					break;
				}else{
				
				 mario.setPosicion_y(mario.getPosicion_y()+1);	
				 c1 = image1.getRGB(centroMario,mario.getPosicion_y());
				 color = new Color(c1);
				 caida++;
				}
			}
			/** Si la caida es muy grande, Mario muere **/
			if (caida>20){
				mario.Muriendo();
				mario.pararSonido();
			}			
			
		/** Si no es negro ni es el color del suelo, sera subir posicion 'y' hasta encontrar aire (o escalera) **/
		}else if (!EsSuelo(color)){
			c1 = image1.getRGB(centroMario,mario.getPosicion_y());
			color = new Color(c1);
			boolean seguirSubiendo=true;
			 if ((EsAire(color))|((EsEscalera(color)))){
				 seguirSubiendo=false;
			 }
			
			/** Mientras no se llegue a color de aire o escalera, subir a Mario **/
			while (seguirSubiendo){
		 	 mario.setPosicion_y(mario.getPosicion_y()-1);	
			 c1 = image1.getRGB(centroMario,mario.getPosicion_y());
			 color = new Color(c1);
			 if ((EsAire(color))|((EsEscalera(color)))){
				 seguirSubiendo=false;
			 }
			}
	
		}
	}
	
	/** Funcion que dado un color, indica si es el color del suelo **/
	public boolean EsSuelo(Color color){
		return (color.getRed()>230 & color.getGreen()<70 & color.getBlue()>138);
	}
	
	/** Funcion que dado un color, indica si es el color del aire **/
	public boolean EsAire(Color color){
		return (color.getRed()==0 & color.getGreen()==0 & color.getBlue()==0);
	}
	
	/** Funcion que dado un color, indica si es el color de una escalera **/
	public boolean EsEscalera(Color color){
		return (color.getRed()<3 & color.getGreen()>240 & color.getBlue()>225);
	}
	
	
	
	
	
}
